package demo.using.redis;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;

import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;

//
//
@Component
public class RedisUtil {
//
    private static final Logger logger = LoggerFactory.getLogger(RedisUtil.class);
//
//    public static String pwd = "123123";
//    public static String url = "127.0.0.1";
//    public static int port = 6379;
//
//    public static Jedis jedis;
//
////    private static void initJedis() {
////        logger.info("获取新的jedis");
////        jedis = RedisManager.getJedis();
////        logger.info("新的jedis为：{}",jedis.toString());
////    }
//
//    private static void finishJedis() {
//        if (jedis != null) {
//            jedis.close();
//        }
//    }
//
//
//    /**
//     * 移出并获取列表的第一个元素
//     *
//     * @param key      键
//     * @param fromLeft 是否从左侧获取
//     * @return 值
//     */
////    public static String pop(String key, boolean fromLeft) {
////        String res;
//////        initJedis();
////        if (fromLeft) {
////            res = RedisManager.getJedis().lpop(key);
////        } else {
////            res = RedisManager.getJedis().rpop(key);
////        }
////        finishJedis();
////        return res;
////    }
//
////    public static Long listPush(String key, String val) {
////        return listPush(key, val, false);
////    }
//
////    public static Long listPush(String key, String val, boolean fromLeft) {
////        Long res;
////        initJedis();
////        if (fromLeft) {
////            res = jedis.lpush(key, val);
////        } else {
////            res = jedis.rpush(key, val);
////        }
////        finishJedis();
////        return res;
////    }
//
////    public static Long listSize(String key) {
////        return jedis.llen(key);
////    }
//
////    public static List<String> listGet(String key, int num) {
////        return listGet(key, 0, num - 1);
////    }
//
////    public static List<String> listGet(String key, int start, int end) {
////        return listGet(key, start, end);
////    }
//
////    public static List<String> listGet(String key) {
//        initJedis();
//        List<String> res = jedis.lrange(key, 0, listSize(key));
//        finishJedis();
//        return res;
//    }
//
//
    public static Set<String> keys() {
        return keys("*");
    }
//
    public static Set<String> keys(String pattern) {
        Jedis jedis = RedisManager.getJedis();
        Set<String> res = jedis.keys(pattern);
        jedis.close();
        return res;
    }
//
//    /**
//     * Redis基本（键）操作
//     * 删除
//     *
//     * @return 被删除 key 的数量
//     */
    public static Long delete(String... keys) {
        Jedis jedis = RedisManager.getJedis();
        Long res = jedis.del(keys);
        jedis.close();
        return res;
    }
//
//    /**
//     * Redis基本（键）操作
//     * 返回 key 所储存的值的类型。
//     *
//     * @return none(key不存在)，string(字符串)，list(列表)，set(集合)，zset(有序集)，hash(哈希表)
//     */
//    public static String type(String key) {
//        initJedis();
//        String res = jedis.type(key);
//        finishJedis();
//        return res;
//    }
//
//    /**
//     * Redis基本（键）操作
//     * 查看某个key的剩余生存时间:time to live
//     *
//     * @return 当 key 不存在或没有设置生存时间时，返回 -1 。否则，返回 key 的剩余生存时间(以秒为单位)。
//     */
//    public static Long ttl(String key) {
//        initJedis();
//        Long res = jedis.ttl(key);
//        finishJedis();
//        return res;
//    }
//
//    /**
//     * Redis基本（键）操作
//     * 查看某个key是否存在
//     *
//     * @param key
//     * @return
//     */
//    public static Boolean exists(String key) {
//        initJedis();
//        Boolean res = jedis.exists(key);
//        finishJedis();
//        return res;
//    }
//
//    /**
//     * Redis基本（键）操作
//     * 设置某一记录的生存时间，过期删除
//     *
//     * @param key     设置可挥发的key
//     * @param seconds 超时时间，单位：秒
//     * @return
//     */
//    public static Long expire(String key, int seconds) {
//        initJedis();
//        Long res = jedis.expire(key, seconds);
//        finishJedis();
//        return res;
//    }
//
//    /**
//     * Redis基本（键）操作
//     * 移除给定 key 的生存时间，将这个 key从可挥发的(带生存时间 key )转换成持久化的(一个不带生存时间、永不过期的 key )
//     *
//     * @param key
//     * @return
//     */
//    public static Long persist(String key) {
//        initJedis();
//        Long res = jedis.persist(key);
//        finishJedis();
//        return res;
//    }
//
//    /**
//     * Redis基本（字符串）操作
//     * 将设置某个key的值，如果 key 已经持有其他值，就覆写旧值，无视类型。
//     *
//     * @param key
//     * @param value
//     * @return
//     */
    public static String set(String key, String value) {
        Jedis jedis = RedisManager.getJedis();
        String res = jedis.set(key, value);
        jedis.close();
        return res;
    }
//
//    /**
//     * Redis基本（字符串）操作
//     * 将 key 的值设为 value ，当且仅当 key不存在，若给定的 key 已经存在，则 SETNX 不做任何动作。
//     * set not exists
//     *
//     * @param value
//     * @return
//     */
//    public Long setnx(String key, String value) {
//        return jedis.setnx(key, value);
//    }
//
//    /**
//     * Redis基本（字符串）操作
//     * 将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位)。
//     *
//     * @param key     键
//     * @param seconds 过期时间，秒
//     * @param value   值
//     * @return
//     */
//    public static String setex(String key, String value, int seconds) {
//        initJedis();
//        String res = jedis.setex(key, seconds, value);
//        finishJedis();
//        return res;
//    }
//
//    /**
//     * Redis基本（字符串）操作
//     * 返回 key 所关联的字符串值。
//     * @param key 键
//     * @return 值
//     */
    public static String get(String key){
        Jedis jedis = RedisManager.getJedis();
        logger.info("当前的jedis为：{}",jedis.toString());
        String res =  jedis.get(key);
        jedis.close();
        return res;
    }
//
//    /**
//     * Redis基本（字符串）操作
//     * 将 key 中储存的数字值增一。
//     * 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
//     * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
//     * @param key 键
//     * @return
//     */
//    public static Long incr(String key){
////        initJedis();
//        Long res =  RedisManager.getJedis().incr(key);
//        finishJedis();
//        return res;
//    }
//
//    /**
//     * Redis基本（字符串）操作
//     * 将 key 中储存的数字值增加固定制。
//     * 如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
//     * 如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
//     * @param key
//     * @return
//     */
//    public Long incrBy(String key, long increase){
////        initJedis();
//        Long res =  RedisManager.getJedis().incrBy(key, increase);
//        finishJedis();
//        return res;
//    }
//
//    /**
//     * Set操作
//     * 将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略
//     * 假如 key 不存在，则创建一个只包含 member 元素作成员的集合
//     * 当 key 不是集合类型时，返回一个错误
//     * @return 被添加到集合中的新元素的数量，不包括被忽略的元素
//     */
    public static Long sadd(String skey, String member){
        Jedis jedis = RedisManager.getJedis();
        Long res = jedis.sadd(skey, member);
        jedis.close();
        return res;
    }
//
//    /**
//     * Set操作
//     * 移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略
//     * @return 被成功移除的元素的数量，不包括被忽略的元素。
//     */
    public static Long srem(String skey, String member){
        Jedis jedis = RedisManager.getJedis();
        Long res =jedis.srem(skey, member);
        jedis.close();
        return res;
    }
//
//    /**
//     * Set操作
//     * 返回集合 key 中的所有成员
//     * 不存在的 key 被视为空集合
//     * @return 集合中的所有成员
//     */
//    public Set<String> smembers(String skey){
//        return jedis.smembers(skey);
//    }
//
//    /**
//     * Set操作
//     * 判断 member 元素是否集合 key 的成员
//     * @return 如果 member 元素是集合的成员，返回true
//     */
//    public Boolean sismember(String skey, String member){
//        return jedis.sismember(skey, member);
//    }
//
//    /**
//     * Set操作
//     * 返回集合 key 的基数(集合中元素的数量)
//     * @return 集合的基数
//     */
    public static Long scard(String skey){
        Jedis jedis = RedisManager.getJedis();
        logger.info("当前的jedis为：{}",jedis.toString());
        Long res =  jedis.scard(skey);
        jedis.close();
        return res;
    }
//
//    /**
//     * Set操作
//     * 移除并返回集合中的一个元素
//     * @return 被移除的元素
//     */
//    public String spop(String skey){
//        return jedis.spop(skey);
//    }
//
//    /**
//     * Set操作
//     * 返回一个集合的全部成员，该集合是所有给定集合的交集
//     * 当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)
//     * @return 交集成员的列表
//     */
//    public Set<String> sinter(String... skeys){
//        return jedis.sinter(skeys);
//    }
//
//    /**
//     * Set操作
//     * 返回一个集合的全部成员，该集合是所有给定集合的并集
//     * @return 并集成员的列表
//     */
//    public Set<String> sunion(String... skeys){
//        return jedis.sunion(skeys);
//    }
//
//    /**
//     * Set操作
//     * 返回一个集合的全部成员，该集合是所有给定集合之间的差集
//     * @return 交集成员的列表
//     */
//    public Set<String> sdiff(String... skeys){
//        return jedis.sdiff(skeys);
//    }
//
//

    public static void main(String[] args) {
        final AtomicInteger i = new AtomicInteger(1);
        while (true) {
            try {
                Thread.sleep(1);
                logger.info(String.valueOf(i.getAndIncrement()));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }

}